package tree;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。
 *
 * 列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。
 *
 *  
 *
 * 示例 1:
 *
 * 输入: [[1,1],2,[1,1]]
 * 输出: [1,1,2,1,1]
 * 解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。
 * 示例 2:
 *
 * 输入: [1,[4,[6]]]
 * 输出: [1,4,6]
 * 解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。
 *
 */
public class NestedIterator  implements Iterator<Integer> {

    private Iterator<Integer> it;

    public NestedIterator(List<NestedInteger> nestedList) {
        List<Integer> result = new ArrayList<>();
        build(nestedList,result);
        this.it = result.iterator();
    }

    @Override
    public Integer next() {
       return it.next();
    }

    @Override
    public boolean hasNext() {
        return it.hasNext();
    }

    public void build(List<NestedInteger> nodes, List<Integer> result){
        if(nodes.isEmpty()){
            return;
        }
        for (NestedInteger node : nodes) {
            if(node.isInteger()){
                result.add(node.getInteger());
            }else{
                build(node.getList(),result);
            }
        }

    }

    public static class NestedInteger {
        private Integer val;
        private List<NestedInteger> list;

        public NestedInteger(Integer val) {
            this.val = val;
            this.list = null;
        }
        public NestedInteger(List<NestedInteger> list) {
            this.list = list;
            this.val = null;
        }

        // 如果其中存的是一个整数，则返回 true，否则返回 false
        public boolean isInteger() {
            return val != null;
        }

        // 如果其中存的是一个整数，则返回这个整数，否则返回 null
        public Integer getInteger() {
            return this.val;
        }

        // 如果其中存的是一个列表，则返回这个列表，否则返回 null
        public List<NestedInteger> getList() {
            return this.list;
        }
    }
}
